\chapter{Resultate}\label{chap:resultate}

\section{LCV Framework}\label{sec:lcv_framework}
Als Haupterzeugnis der Projektarbeit wurde ein Framework (oder auch Programmierschnittstelle) für das LCV-Board entwickelt. Dieses Framework soll die Arbeit zukünftiger Entwickler erleichtern. Es stellt LCV-Spezifische Funktionalität zur Verfügung welche komfortabel genutzt werden kann. Dies nimmt dem Programmierer viel Kleinarbeit ab, schliesst Fehlerquellen aus und spart so Entwicklungszeit- und Kosten.\\
Zusätzlich wird auch von der Hardware abstrahiert. Es wird so möglich LCV-Programme ohne ein eigentliches LCV-Board zu schreiben und zu testen. Die LCV-Hardware kann auf einem ''Host''-Computer simuliert werden. Eine konkrete Implementation einer solchen Simulation für Linux wurde ebenfalls realisiert. Es gilt aber zu beachten, dass das Framework zwar die Hardware simulieren kann; das Verhalten der Umwelt (welche an diese Hardware angeschlossen ist) muss jedoch vom Programmierer selbst simuliert werden. Ein weiter Vorteil der Abstraktion ist, dass bei Hardware-Änderungen zwar das Framework (bzw. dessen Konfiguration) angepasst werden muss, darauf basierende Anwendungen bleiben hingegen von Änderungen verschont.

\subsection{Aufbau und Konzept}\label{subsec:aufbau_und_konzept}
Das Framework ist modular aufgebaut und berücksichtigt verschiedene Ansätze und Konzepte aus der objektorienterten Programmierung wie Kapselung, Austauschbarkeit, Wiederverwendbarkeit und leichte Koppelung. Jedes Modul des LCV-Frameworks hat einen klar fokussierten Aufgaben- und Verantwortungsbereich. Hardwarekomponenten werden ebenfalls durch ein Modul repräsentiert. Module sollen ohne grossen Aufwand hinzugefügt, entfernt oder erweitert werden können. Detailliertere Informationen über die jeweiligen Module folgen im entsprechenden Absatz.

\subsection{Parallelität}
Beim Framework wurde davon ausgegangen, dass die Hardware nur von einem Programm benutzt wird. Sollen mehrere Programme zusammenarbeiten, so müssen sie von Grund auf dafür konzipiert sein. Es muss sichergestellt werden, dass die Programme sich nicht gegenseitig manipulieren (verändert beispielsweise ein Programm ein Konfigurationsregister auf der Kamera, so hat dies auch auf alle andern Programme Auswirkungen, welche Bilder von der Kamera holen). In Rücksprache mit der SCS haben wir beschlossen keine Werkzeuge zum Multiprozessmanagment  in das Framework zu integrieren, da im normalen Anwendungsbereich stets nur ein Bildverarbeitungsprozess auf der Kamera läuft. Besonders bei Sicherheitsrelevanten Anwendungen oder Echtzeitumgebungen kann Multiprocessing zu grossen Problemen führen.

\subsection{Portierbarkeit}
\subsubsection{Hostsystem}
Eine Hostseitige Portierung der Linux-Implementierung auf ein anderes Betriebssystem wie Windows oder Macintosh ist generell vorgesehen und sollte relativ einfach realisierbar sein. Aus diesem Grund wurden nur Standardbibliotheken eingesetzt.
\subsubsection{Zielsystem}
Eine Portierung auf ein neues Zielsystem kann notwendig werden, wenn Hardware ausgetauscht, bzw. erneuert wird und veränderte Eigenschaften aufweist. Bei kleineren Änderungen reicht es dank der generischen Konzeption aus, die Konfigurationsdateien im jeweiligen Modul anzupassen. Grössere Änderungen können aber auch eine Anpassung der Implementation notwendig machen (beispielsweise wenn ein anderes Kommunikationsprotokoll benutzt werden muss).

\subsection{Strukturen}
\begin{description}
\item[image\_types] Ein Enum mit den Bildtypen. Mögliche Werte sind IMG\_BGR und IMG\_GRAYSCALE.
\item[image\_type] Der image\_types Enum als Typedef.
\item[lcv\_picture] Die Struktur für ein Bild. Als Komponenten enthält die Struktur die Bilddaten als Bytearray, die Länge dieses Arrays, die Bildbreite, die Bildhöhe und den Bildtyp.
Die Bilddaten sind bottom-up abgelegt. Der Nullpunkt des Koordinatensystems befindet sich links unten. Je nach Bildtyp sind die Bilddaten unterschiedlich zu interpretieren.
Beim IMG\_BGR Bildtyp handelt es sich um ein RGB Bild mit einer Farbtiefe von 24 bpp. Die Daten jedes Pixels bestehen aus jeweils einem Byte für den Blau-, Grün- und Rot-Kanal (in dieser Reihenfolge).
Beim IMG\_GRAYSCALE Bildtyp handelt es sich um ein 8-bit Graustufenbild. Die Daten jedes Pixels bestehen aus einem Byte mit dem jeweiligen Graustufenwert.
\begin{center}
 \includegraphics[width=350pt]{bildmatrix.png}
 \mycaption{figure}{Aufbau eines RGB-Bildes}
\end{center}
\item[lcv\_reg\_config] Die Konfigurationsstruktur für ein Kameraregister. Es müssen die Adresse, Minimalwert, Maximalwert und Standardwert konfiguriert werden.
\item[lcv\_gpio\_config] Die Konfigurationsstruktur für ein GPIO Port. Es muss jeweils der Devicename als String angegeben werden.
\item[lcv\_pixel\_bgr] Die Struktur für einen 24-bit RGB Pixel. Sie wird momentan nicht verwendet, sondern ist für Erweiterungen gedacht.
\item[lcv\_pixel\_gray] Die Struktur für einen 8-bit Graustufenpixel. Sie wird momentan nicht verwendet, sondern ist für Erweiterungen gedacht.
\end{description}

\subsection{Module}
\begin{center}
 \includegraphics[width=400pt]{framework_aufbau.png}
 \mycaption{figure}{Aufbau des LCV Frameworks}
\end{center}

\subsubsection{Kamera Modul (cam.h)}
\paragraph{Zweck}
Das Kameramodul repräsentiert die Schnittstelle zur Kamera, bzw. zum CMOS-Sensor.
\paragraph{Funktionen}
\begin{description}
\item[lcv\_capture\_frame()] Holt ein Bild von der Kamera. Auf dem Zielsystem wird zusätzlich eine Bayer-Transformation der Sensordaten durchgeführt. \\
Auf dem Hostsystem muss der Dateinamen eines Bild mitgegeben werden, welches das Kamerabild simuliert.
\item[lcv\_capture\_region()] Holt einen Bildausschnitt von der Kamera ohne die Kameraregister nachhaltig zu verändern.\\
Diese Funktion wurde nicht implementiert.
\item[lcv\_config\_write()] Schreibt einen Wert in ein Konfigurationsregister. Auf dem Hostsystem hat dies keine weiteren Auswirkungen, sondern wird nur in der Protokolldatei vermerkt.
\item[lcv\_config\_read()] Liest einen Wert aus einem Konfigurationsregister.
\item[lcv\_regs\_to\_default()] Setzt alle Register auf den vorkonfigurierten Standardwert.
\item[lcv\_reg\_buffering()] Aktiviert oder Deaktiviert das Zwischenspeichern der Registerwerte. Standardmässig ist das Zwischenspeichern aktiviert. Wenn man sicherstellen will, dass die Register immer geschrieben und gelesen werden sollen, so muss die Zwischenspeicherung explizit deaktiviert werden. Da die Kommunikation über einen I2C Bus allerdings relativ langsam von Statten geht, können so grosse Zeitverlust entstehen.
\end{description}
\paragraph{Konfiguration}
Die Register der Kamera sind konfigurierbar. Es kann Registeradresse, Minimalwert, Maximalwert und Standardwert eingestellt werden.
Entsprechende Konfigurationen befinden sich in der Datei \textit{cam-reg-config.h} und \textit{cam-config.h}
Da die Kommunikation zu den Registern über einen I2C-Bus läuft, muss das entsprechende Device und die ID in \textit{cam-config.h} eingetragen werden.
\paragraph{Hardware-Abhängigkeiten}
Die Funktionen zum Schreiben, bzw. Lesen der Konfigurationsregister benötigen einen I2C Bus zur Kamera.\\
Um ein Bild von der Kamera zu holen wird der entsprechender Treiber benutzt.

\subsubsection{GPIO Modul (gpio.h)}
\paragraph{Zweck}
Das GPIO-Modul repräsentiert die General-Purpos Input und Output Ports des Boards.
\paragraph{Funktionen}
\begin{description}
\item[lcv\_gpio\_read()] Liest den Wert eines GP-Input Pins.
\item[lcv\_gpio\_write()] Schreibt auf einen GP-Output Pin. Auf dem Hostsystem wird dies in der Protokolldatei vermerkt.
\item[lcv\_gpio\_simulate\_input()] Simuliert ein Eingangssignal an der Hardware. Diese Funktion wird nur auf dem Hostsystem benötigt.
\item[lcv\_gpio\_simulate\_output()] Ermöglicht das Festlegen eines Handlers, der bei jedem Schreibvorgang auf einen Outport aufgerufen wird. Der Programmierer kann so das Verhalten der Umwelt simulieren. Diese Funktion wird nur auf dem Hostsystem benötigt.
\end{description}
\paragraph{Konfiguration}
Die Konfiguration der GP In- und Outports erfolgt in den Dateien\textit{ gpio-port-config.h} und \textit{gpio-config.h}
Theoretisch können je 256 verschiedene GPIOs konfiguriert werden.
\paragraph{Hardware-Abhängigkeiten}
Der Einsatz des GPIO-Moduls setzt das Einbinden eines funktionierenden pflags-Treibers voraus.

\subsubsection{Digital Image Processing Modul (dip.h)}
\paragraph{Zweck}
Dieses Modul enthält eine Sammlung von Bildverarbeitungsfunktionen bzw. Algorithmen. 
\paragraph{Funktionen}
\begin{description}
\item[lcv\_clone\_picture()] Erstellt die Kopie eines LCV-Bildes.
\item[lcv\_free\_picture()] Gibt die Daten in einem LCV-Bild frei. Achtung: Beim Löschen eines Bildes werden die Daten nicht automatisch freigegeben, daher sollte immer diese Funktion verwendet werden.
\item[lcv\_invert()] Invertiert ein LCV-Bild.
\item[lcv\_reverse()] Dreht ein Bild um 180 Grad.
\item[lcv\_avg\_value()] Berechnet den Mittelwert eines Bildes.
\item[lcv\_rgb2gray()] Wandelt ein RGB-Bild in ein Graustufenbild um.
\item[lcv\_gray2rgb()] Wandelt ein Graustufenbild in ein RGB-Bild um.
\end{description}
\paragraph{Konfiguration}
Keine
\paragraph{Hardware-Abhängigkeiten}
Keine

\subsubsection{BMP Modul (bmp.h)}
\paragraph{Zweck}
Das BMP-Modul stellt Funktionen für den Umgang mit Windows-Bitmap Bildern zur Verfügung. 
\paragraph{Funktionen}
\begin{description}
\item[lcv\_write\_bmp()] Legt ein Bild im BMP-Format ab. Die Farbtiefe beträgt 24 bpp und das Bild wird nicht indiziert.
\item[lcv\_read\_bmp()] Liest ein Bild im BMP-Format. Das Bild muss im Windows-Bitmap Format Version 3 mit einer Farbtiefe von 24 bpp und ohne Farbtabelle vorliegen.
\item[lcv\_get\_data\_offset()] Liest den Datenoffset aus einem BMP-Header.
\item[lcv\_set\_data\_offset()] Setzt den Datenoffset in einem BMP-Header.
\item[lcv\_get\_height()] Liest die Bildhöhe aus einem BMP-Header.
\item[lcv\_set\_height()] Setzt die Bildhöhe in einem BMP-Header.
\item[lcv\_get\_width()] Liest die Bildbreite aus einem BMP-Header.
\item[lcv\_set\_width()] Setzt die Bildbreite in einem BMP-Header.
\item[lcv\_get\_colordepth()] Liest die Farbtiefe aus einem BMP-Header.
\end{description}
\paragraph{Konfiguration}
Keine
\paragraph{Hardware-Abhängigkeiten}
Keine

\subsubsection{Protokoll Modul (log.h)}
\paragraph{Zweck}
Dieses Modul hilft dem Programmierer den Programmablauf zu Protokollieren. Der Ablauf und möglicherweise aufgetretene Fehler sollen auch nach der Ausführung noch nachvollzogen und transparent gemacht werden können.
\paragraph{Funktionen}
\begin{description}
\item[lcv\_logging()] Ermöglicht die Protokollierung ein- oder auszuschalten. Standardmässig ist die Protokollierung eingeschaltet.
\item[lcv\_log()] Schreibt einen Eintrag in die Protokolldatei.
\item[lcv\_log\_error()] Schreibt einen Fehlereintrag in die Protokolldatei.
\item[lcv\_log\_warning()] Schreibt einen Warneintrag in die Protokolldatei.
\end{description}
\paragraph{Konfiguration}
Der Name der Protokolldatei kann in \textit{log-config.h} verändert werden.
\paragraph{Hardware-Abhängigkeiten}
Keine

\subsubsection{I2C Modul (i2c.h)}
\paragraph{Zweck}
Das I2C Modul ermöglicht die Kommunikation über ein entsprechendes Bussystem.
\paragraph{Funktionen}
\begin{description}
\item[lcv\_i2c\_write\_register()] Schreibt in ein Register.
\item[lcv\_i2c\_read\_register()] Liest von einem Register.
\item[lcv\_i2c\_dump\_register()] Dumpt ein Register.
\item[lcv\_i2c\_scan\_bus()] Scannt den I2C Bus und gibt die Resultate in der Konsole aus.
\end{description}
\paragraph{Konfiguration}
Keine
\paragraph{Hardware-Abhängigkeiten}
Für die Benutzung muss ein I2C Device zur Verfügung stehen.

\section{Anleitungen und Tutorials}
Während der Projektarbeit wurden Anleitungen und Tutorials erstellt, die das Programmieren mit unserem Framework und das Arbeiten mit dem LCV Board erleichtern sollen. Diese Anleitungen werden von uns als Bestandteil der Projektarbeit betrachtet und befinden sich im Anhang der Dokumentation.
\begin{itemize}
\item Voraussetzungen für die Software-Entwicklung (\ref{chap:voraussetzungen})
\item LCV Software-Entwicklung (\ref{chap:softwareentwicklung})
\item Entwickeln mit Eclipse (\ref{chap:eclipse})
\end{itemize}

\section{Testprogramm}
Um die Module des Frameworks zu testen wurde ein umfangreiches Testprogramm erstellt. Dieses Testprogramm soll gleichzeitig veranschaulichen, wie die Funktionen zu verwenden sind. \\
Als Resultat des Framework-Tests wird nach einem fehlerfreien Durchlauf eine HTML-Seite (\textit{fw.html}) mit einigen Testbildern erstellt. Auf dem Zielsystem wird die Seite automatisch ins Webverzeichnis kopiert, so dass sie über Ethernet aufgerufen werden kann.
\begin{center}
 \includegraphics[width=450pt]{testbilder.png}
 \mycaption{figure}{Screenshot der HTML Seite}
\end{center}

Auf dem Hostsystem wurde Valgrind\cite{valgrind} zur Überprüfung der Speicheralloziierung vewendet. Laut dem Testresultat existieren keine Memory Leaks:

\begin{verbatim}
bash> valgrind --leak-check=yes --show-reachable=yes ./lcv-framwork-test

==9222== Memcheck, a memory error detector.
==9222== Copyright (C) 2002-2007, and GNU GPL'd, by Julian Seward et al.
==9222== Using LibVEX rev 1732, a library for dynamic binary translation.
==9222== Copyright (C) 2004-2007, and GNU GPL'd, by OpenWorks LLP.
==9222== Using valgrind-3.2.3-Debian, a dynamic binary instrumentation framework.
==9222== Copyright (C) 2000-2007, and GNU GPL'd, by Julian Seward et al.
==9222== For more details, rerun with: -v
==9222==
STARTING TEST PROGRAMM

LOG-MODULE:
writing into logfile... ok
disable logging... ok
logging an entry wich must not be written to the logfile... ok
enable logging... ok

GPIO-MODULE:
reading port IN_0: 1
reading port IN_1: 1
writing 1 to port OUT_0
writing 0 to port OUT_0
simulating input 0 at port 0
reading port IN_0: 0
setting output event-handler
writing 1 to port OUT_0
GPIO Event-Handler was called:
 -> gpio_write_simulator(0, 1)

CAM-MODULE:
Testing registers:
read analog_gain... value is: 16
write analog_gain to 20... register written
read analog_gain...value is: 20
read illegal register... ok
write illegal register... detected (returned an error-msg)
configure camera... ok
Testing Capture-Functions:
capture frame... ok

DIP-MODULE:
capturing frame (should have been tested before)... ok
writing invert bmp... ok
writing reversed bmp... ok
writing gray bmp... ok
writing gray inverted bmp... ok
writing gray reversed bmp... ok
averange value of gray... 226

HTML-VIEW:
writing html file... ok

TEST COMPLETED
==9222== 
==9222== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 11 from 1)
==9222== malloc/free: in use at exit: 0 bytes in 0 blocks.
==9222== malloc/free: 56 allocs, 56 frees, 16,250,877 bytes allocated.
==9222== For counts of detected errors, rerun with: -v
==9222== All heap blocks were freed -- no leaks are possible.
\end{verbatim}

\section{uClinux Erweiterungen}
Wir haben als Grundlage die von Fabian Brugger portierte uClinux Version übernommen. Im Verlauf unserer Arbeit wurden folgende Kernelmodule und Programme hinzugefügt:

\begin{description}
\item[Pflags Treiber] Der Pflags Treiber wird vom GPIO Modul unseres Frameworks benötigt. Er stellt unter \textit{/dev} Character Devices als Schnittstelle zu den eigentlichen GPIO Ports
zur Verfügung. Der Pflags Treiber ist in der Kernelkonfiguration unter \textit{ Kernel/Library/Defaults Selection  $\rightarrow$ Customize Kernel Settings $\rightarrow$ Device Drivers $\rightarrow$ Character Devices $\rightarrow$ Blackfin BF53x Programmable Flags Driver} eingetragen. 
\item[lrz] Teil der Zmodem Tools. Wird zum Empfangen von Dateien über die Serielle Schnittstelle verwendet. Damit ist es möglich, Programme auf dem Zielsystem zu testen, ohne den Kernel neu kompilieren zu müssen oder die Dateien per FTP zu übertragen. Das Programm befindet sich unter \textit{ Kernel/Library/Defaults Selection $\rightarrow$ Customize Vendor/User Settings $\rightarrow$  Miscellaneous Applications  $\rightarrow$  zmodem utils  $\rightarrow$ lrz}. 
\item[lsz] Teil der Zmodem Tools. Wird zum Senden von Dateien über die Serielle Schnittstelle verwendet. Damit kann man z.B auf dem LCV Board gespeicherte Bilder auf das Hostsystem übertragen. Das Programm befindet sich unter \textit{ Kernel/Library/Defaults Selection $\rightarrow$ Customize Vendor/User Settings $\rightarrow$  Miscellaneous Applications  $\rightarrow$  zmodem utils  $\rightarrow$ lsz}. 
\item[LCV-Framwork-Test] Wir haben uns entschieden, das Testprogramm des Framworks als Programmoption zur Verfügung zu stellen. Es ist unter \textit{Kernel/Library/Defaults Selection $\rightarrow$ Customize Vendor/User Settings $\rightarrow$ Blackfin test programs $\rightarrow$ LCV Framwork Test} eingetragen.
\end{description}